{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T06:19:51.065242Z",
     "start_time": "2025-01-09T06:19:48.815094Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=False)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                               {'city': '上海', 'temperature': 60},\n",
    "                               {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T01:47:12.347620Z",
     "start_time": "2025-01-09T01:47:12.339395Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.   1.   0. 100.]\n",
      " [  1.   0.   0.  60.]\n",
      " [  0.   0.   1.  30.]]\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(res)\n",
    "    print('-'*50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-'*50)\n",
    "    print(res.toarray()) #稀疏矩阵转换为数组\n",
    "    print('-'*50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T01:58:54.939670Z",
     "start_time": "2025-01-09T01:58:54.930569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(data) #稀疏存储，只记录非零位置\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:37:39.897856Z",
     "start_time": "2025-01-09T02:37:39.884438Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword() #jieba分词好的中文文本\n",
    "    print('-'*50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-'*50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T02:49:06.518653Z",
     "start_time": "2025-01-09T02:49:05.864431Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Dumping model to file cache C:\\Users\\余彬\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.627 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-'*50)\n",
    "    print(type(data))\n",
    "    print('-'*50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T03:02:03.832293Z",
     "start_time": "2025-01-09T03:02:03.805726Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-'*50)\n",
    "    out=mm.transform([[1, 2, 3, 4],[6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T03:08:07.994775Z",
     "start_time": "2025-01-09T03:08:07.977479Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": [
    "(1-60)/30"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:15:22.450995Z",
     "start_time": "2025-01-09T03:15:22.437607Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data=stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T03:18:58.359883Z",
     "start_time": "2025-01-09T03:18:58.347732Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:20:53.557402Z",
     "start_time": "2025-01-09T03:20:53.543113Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform(data)\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:24:10.563963Z",
     "start_time": "2025-01-09T03:24:10.552342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.48029737e-16  7.40148683e-17  7.40148683e-17]\n",
      "[1. 1. 1.]\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "source": [
    "(np.square(1-2.333)+np.square(2-2.333)+np.square(4-2.333))/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:24:46.149987Z",
     "start_time": "2025-01-09T03:24:46.140417Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "source": [
    "(1-2.333)/np.sqrt(1.55555)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T03:25:11.150085Z",
     "start_time": "2025-01-09T03:25:11.139194Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T06:20:03.245407Z",
     "start_time": "2025-01-09T06:20:03.235503Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "3.6666666666666665"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11/3"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:22:34.367453500Z",
     "start_time": "2024-07-11T02:22:34.322497700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "nan"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan+10"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-07-11T02:23:44.133095700Z",
     "start_time": "2024-07-11T02:23:44.114673600Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T06:29:48.801400Z",
     "start_time": "2025-01-09T06:29:48.793517Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum()) #最初数据的方差\n",
    "    print('-'* 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-'*50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-01-09T06:59:15.857328Z",
     "start_time": "2025-01-09T06:59:15.843661Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "source": [
    "22/29.333333333333336"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T06:59:20.801965Z",
     "start_time": "2025-01-09T06:59:20.780368Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "x = np.random.rand(10000) #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t,x,'g.',label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-01-09T06:59:35.697177Z",
     "start_time": "2025-01-09T06:59:34.388883Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 7
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
